package model

import (
	"back/app/config"
	"encoding/json"
	"errors"
	"os"
	"time"
)

/**
 * 构造函数, 得到实例
 */
func NewAdmin() *Admin {
	temp := &Admin{
		AdduserData:          AdduserData{},
		RemoveUserData:       RemoveUserData{},
		CheckFeedbackData:    CheckFeedbackData{},
		CheckUserListData:    CheckUserListData{},
		RemoveManagerData:    RemoveManagerData{},
		AddManagerData:       AddManagerData{},
		ReplyFbData:          ReplyFbData{},
		CheckApplyListData:   CheckApplyListData{},
		CheckManagerListData: CheckManagerListData{},
		CheckAllUser:         CheckAllUserListData{},
		LoginLogList:         LoginLogList{},
	}

	return temp
}

/**
 * 管理员添加普通用户
 */
func (u *Admin) addUser(cont string) (err error) {
	data := &u.AdduserData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析管理员添加用户数据")
	user := new(ReceiveAdduser)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("数据解析管理员添加用户失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("解析管理员添加用户数据结束")

	config.GetLogger().Info("开始判断添加者是否为管理员")
	tempType := 0
	err = db.Table("user_info").Where("id = ?", user.ManagerID).Select("Type").Row().Scan(&tempType)
	if err != nil {
		data.Adduser = false
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if tempType < 1 {
		data.Adduser = false
		config.GetLogger().Warnw("添加者不为管理员",
			"err", errors.New("添加者不为管理员"),
		)
		return errors.New("添加者不为管理员")
	}
	config.GetLogger().Info("判断添加者是否为管理员结束")

	config.GetLogger().Info("开始判断是否存在此普通用户")
	num := -1
	err = db.Table("user_info").Where("user = ? AND type = 0", user.NormalName).Count(&num).Error
	if err != nil {
		data.Adduser = false
		config.GetLogger().Warnw("判断此普通用户是否存在失败",
			"err", err,
		)
		return
	}
	if num != 1 {
		data.Adduser = false
		config.GetLogger().Warnw("不存在此普通用户",
			"err", errors.New("不存在此普通用户"),
		)
		return errors.New("不存在此普通用户")
	}
	config.GetLogger().Info("判断是否存在此普通用户结束")

	config.GetLogger().Info("开始查询普通用户的ID")
	userID := ""
	err = db.Table("user_info").Where("user = ?", user.NormalName).Select("id").Row().Scan(&userID)
	if err != nil {
		data.Adduser = false
		config.GetLogger().Warnw("用户ID查询失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("查询普通用户的ID结束")

	config.GetLogger().Info("开始判断用户是否已被添加")
	num = -1
	err = db.Table("relationship").Where("normal_id = ?", userID).Count(&num).Error
	if err != nil {
		data.Adduser = false
		config.GetLogger().Warnw("判断用户是否已被添加失败",
			"err", err,
		)
		return
	}
	if num != 0 {
		data.Adduser = false
		temp := ""
		_ = db.Table("relationship").Where("normal_id = ?", userID).Select("manager_id").Row().Scan(&temp)
		if temp == user.ManagerID {
			config.GetLogger().Warnw("该用户已被您添加",
				"err", errors.New("该用户已被您添加"),
			)
			return errors.New("该用户已被您添加")
		} else {
			config.GetLogger().Warnw("该用户已被其他管理员添加",
				"err", errors.New("该用户已被其他管理员添加"),
			)
			return errors.New("该用户已被其他管理员添加")
		}
	}
	config.GetLogger().Info("判断用户是否已被添加结束")

	config.GetLogger().Info("开始将管理员与用户的关系存入数据库")
	ur := new(UserRelationship)
	ur.ManagerID = user.ManagerID
	ur.NormalID = userID
	//数据库中新建一个用户关系记录
	if err = db.Table("relationship").Create(ur).Error; err != nil {
		data.Adduser = false
		config.GetLogger().Warnw("插入失败",
			"err", err,
		)
		return
	}
	data.Adduser = true
	config.GetLogger().Info("将管理员与用户的关系存入数据库结束")
	return
}

/**
 *管理员移除普通用户
 */
func (u *Admin) removeUser(cont string) (err error) {
	data := &u.RemoveUserData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析管理员移除普通用户数据")
	user := new(ReceiveRemoveUser)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("管理员移除普通用户数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("解析管理员移除普通用户数据结束")

	config.GetLogger().Info("开始判断操作者是否为管理员")
	tempType := 0
	err = db.Table("user_info").Where("id = ?", user.ManagerID).Select("Type").Row().Scan(&tempType)
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if tempType < 1 {
		data.RemoveUser = false
		config.GetLogger().Warnw("操作者不为管理员",
			"err", errors.New("操作者不为管理员"),
		)
		return errors.New("操作者不为管理员")
	}
	config.GetLogger().Info("判断操作者是否为管理员结束")

	config.GetLogger().Info("开始判断管理员是否有该普通用户")
	count := 0
	err = db.Table("relationship").Where("manager_id = ? AND normal_id = ?", user.ManagerID, user.NormalID).Count(&count).Error
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("判断管理员是否有该普通用户失败",
			"err", err,
		)
		return
	}
	if count != 1 {
		data.RemoveUser = false
		config.GetLogger().Warnw("该管理员没有该普通用户",
			"err", errors.New("该管理员没有该普通用户"),
		)
		return errors.New("该管理员没有该普通用户")
	}
	config.GetLogger().Info("判断管理员是否有该普通用户结束")

	config.GetLogger().Info("开始解除管理员与普通用户关系")
	remove := new(RemoveUserRelationship)
	err = db.Table("relationship").Where("manager_id = ? AND normal_id = ?", user.ManagerID, user.NormalID).Delete(&remove).Error
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("管理员移除普通用户失败",
			"err", err,
		)
		return
	}
	data.RemoveUser = true
	config.GetLogger().Info("管理员移除普通用户成功")
	return
}

/**
 *超级管理员移除用户
 */
func (u *Admin) delUser(cont string) (err error) {
	data := &u.RemoveUserData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析数据")
	user := new(ReceiveRemoveUser)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("数据解析结束")

	config.GetLogger().Info("开始查询管理员权限并验证用户有效性")
	tempType := 0
	err = db.Table("user_info").Where("id = ?", user.ManagerID).Select("type").Row().Scan(&tempType)
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("管理员移除普通用户失败",
			"err", err,
		)
		return
	}
	if tempType != 2 {
		data.RemoveUser = false
		config.GetLogger().Warnw("管理员权限不够",
			"管理员权限不够",
		)
		return errors.New("管理员权限不足")
	}
	count := 0
	err = db.Table("user_info").Where("id = ?", user.NormalID).Count(&count).Error
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("管理员移除普通用户失败",
			"err", err,
		)
		return
	}
	if count == 0 {
		data.RemoveUser = false
		config.GetLogger().Warnw("要删除的用户不存在")
		return errors.New("要删除的用户不存在")
	}
	err = db.Table("user_info").Where("id = ?", user.NormalID).Select("type").Row().Scan(&tempType)
	if tempType == 2 {
		data.RemoveUser = false
		config.GetLogger().Warnw("超管之间无法互删")
		return errors.New("超管之间无法互删")
	}
	config.GetLogger().Info("查询管理员权限并验证用户有效性结束")

	config.GetLogger().Info("开始删除用户")
	table := [6]string{"dealt_run", "dealt_walk", "dealt_shakehand", "origin_run", "origin_walk", "origin_shakehand"}
	dealt := new(DealtData)
	origin := new(OriginData)
	info := new(Info)
	relation := new(UserRelationship)
	feedback := new(Feedback)
	apply := new(ApplyManagerRecord)
	login := new(LoginLog)
	userName := ""

	err = db.Table("user_info").Where("id = ?", user.NormalID).Select("user").Row().Scan(&userName)
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("管理员移除普通用户失败",
			"err", err,
		)
		return
	}

	//开始删除用户历史数据
	config.GetLogger().Info("开始删除用户历史数据")
	//启用事务，若删除失败则全部回滚
	tx := db.Begin()
	for i := 0; i < 6; i++ {
		if i < 3 {
			err = tx.Table(table[i]).Where("uid = ?", user.NormalID).Delete(&dealt).Error
			if err != nil {
				data.RemoveUser = false
				config.GetLogger().Warnw("超级管理员删除用户失败",
					"err", err,
				)
				tx.Rollback()
				return
			}
		} else {
			err = tx.Table(table[i]).Where("uid = ?", user.NormalID).Delete(&origin).Error
			if err != nil {
				data.RemoveUser = false
				config.GetLogger().Warnw("超级管理员删除用户失败",
					"err", err,
				)
				tx.Rollback()
				return
			}
		}
	}
	config.GetLogger().Info("删除用户历史数据结束")

	config.GetLogger().Info("开始删除用户关系")
	err = tx.Table("relationship").Where("manager_id = ?", user.NormalID).Or("normal_id = ?", user.NormalID).Delete(&relation).Error
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("超级管理员删除用户关系失败",
			"err", err,
		)
		tx.Rollback()
		return
	}
	config.GetLogger().Info("删除用户关系结束")

	config.GetLogger().Info("开始删除用户的管理员申请")
	err = tx.Table("apply").Where("uid = ?", user.NormalID).Delete(&apply).Error
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("删除用户的管理员申请失败",
			"err", err,
		)
		tx.Rollback()
		return
	}
	config.GetLogger().Info("删除用户的管理员申请结束")

	config.GetLogger().Info("开始删除用户反馈")
	err = tx.Table("feedback").Where("uid = ?", user.NormalID).Delete(&feedback).Error
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("超级管理员删除用户反馈失败",
			"err", err,
		)
		tx.Rollback()
		return
	}
	config.GetLogger().Info("删除用户反馈结束")

	config.GetLogger().Info("开始删除用户登录信息")
	err = tx.Table("login").Where("username = ?", userName).Delete(&login).Error
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("超级管理员删除用户登录信息失败",
			"err", err,
		)
		tx.Rollback()
		return
	}
	config.GetLogger().Info("删除用户登录信息结束")

	config.GetLogger().Info("开始删除用户信息")
	err = tx.Table("user_info").Where("id = ?", user.NormalID).Delete(&info).Error
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("超级管理员删除用户信息失败",
			"err", err,
		)
		tx.Rollback()
		return
	}
	config.GetLogger().Info("删除用户信息结束")

	config.GetLogger().Info("开始删除用户目录及文件")
	//windows
	//dir := ".\\data\\" + userName
	//linux
	dir := "./data/" + userName
	err = os.RemoveAll(dir)
	if err != nil {
		data.RemoveUser = false
		config.GetLogger().Warnw("删除用户目录失败",
			"err", err,
		)
		tx.Rollback()
		return
	}
	tx.Commit()
	config.GetLogger().Info("删除用户目录及文件结束")

	config.GetLogger().Info("删除用户结束")
	data.RemoveUser = true
	return
}

/*
 * 超级管理员查看用户反馈
 */
func (u *Admin) CheckFeedback(cont string) (err error) {
	data := &u.CheckFeedbackData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析数据")
	user := new(ReceiveFeedBackList)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("数据解析结束")

	config.GetLogger().Info("开始判断是否为超管")
	temp := 0
	err = db.Table("user_info").Where("id = ?", user.SuperID).Select("type").Row().Scan(&temp)
	if err != nil {
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if temp != 2 {
		config.GetLogger().Warnw("不是超管",
			"err", errors.New("不是超管"),
		)
		return errors.New("不是超管")
	}
	config.GetLogger().Info("判断是否为超管结束")

	config.GetLogger().Info("开始查询反馈总数")
	err = db.Table("feedback").Count(&data.Sum).Error
	if err != nil {
		config.GetLogger().Warnw("获取用户反馈记录信息失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("查询反馈总数结束")

	//用户反馈列表
	config.GetLogger().Info("开始获取用户反馈信息")
	rows, err := db.Table("feedback").Order("status").Order("time desc").Joins("join user_info on user_info.id = feedback.uid").
		Limit(user.PageSize).Offset((user.PageNum - 1) * user.PageSize).Select("feedback.id, uid, user, feedback, answer, status, tel, time").Rows()

	if err != nil {
		config.GetLogger().Warnw("获取用户反馈信息失败",
			"err", err,
		)
		return
	}

	for rows.Next() {
		temp := new(CheckFeedback)
		temp.FbID = ""
		temp.UserID = ""
		temp.UserName = ""
		temp.Content = ""
		temp.Status = ""
		temp.Tel = ""
		tempTime := time.Now()

		err = rows.Scan(&temp.FbID, &temp.UserID, &temp.UserName, &temp.Content, &temp.Answer, &temp.Status, &temp.Tel, &tempTime)
		if err != nil {
			config.GetLogger().Warnw("数据获取错误",
				"err:", err,
			)
			return err
		}
		temp.Time = tempTime.Format("2006-01-02 15:04:05")

		data.CheckFeedback = append(data.CheckFeedback, *temp)
	}

	config.GetLogger().Info("获取用户反馈信息结束")

	return
}

/**
 * 管理员查看用户列表
 */
func (u *Admin) CheckUserList(cont string) (err error) {
	data := &u.CheckUserListData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析管理员查看用户列表数据")
	user := new(ReceiveCheckUserList)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("管理员查看用户列表数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("解析管理员查看用户列表数据结束")

	config.GetLogger().Info("开始判断操作者是否为管理员")
	tempType := 0
	err = db.Table("user_info").Where("id = ?", user.ManagerID).Select("Type").Row().Scan(&tempType)
	if err != nil {
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if tempType < 1 {
		config.GetLogger().Warnw("操作者不为管理员",
			"err", errors.New("操作者不为管理员"),
		)
		return errors.New("操作者不为管理员")
	}
	config.GetLogger().Info("判断操作者是否为管理员结束")

	config.GetLogger().Info("开始查询用户总数")
	err = db.Table("relationship").Where("manager_id = ?", user.ManagerID).Count(&data.Sum).Error
	if err != nil {
		config.GetLogger().Warnw("获取用户信息失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("查询用户总数结束")

	//用户列表
	config.GetLogger().Info("开始获取用户列表信息")
	rows, errs := db.Table("relationship").Where("manager_id=?", user.ManagerID).Select("normal_id,User").
		Joins("join user_info on user_info.id=relationship.normal_id").Limit(user.PageSize).Offset((user.PageNum - 1) * user.PageSize).Rows()
	if errs != nil {
		config.GetLogger().Warnw("获取用户列表信息失败",
			"err", errs.Error,
		)
		return
	}

	for rows.Next() {
		temp := new(CheckUserData)
		temp.UserID = ""
		temp.UserName = ""

		err = rows.Scan(&temp.UserID, &temp.UserName)
		if err != nil {
			config.GetLogger().Warnw("数据获取错误",
				"err:", err,
			)
			return err
		}
		data.List = append(data.List, *temp)
	}
	config.GetLogger().Info("获取用户列表信息结束")
	return
}

/**
 * 超管移除管理员
 */
func (u *Admin) RemoveManager(cont string) (err error) {
	data := &u.RemoveManagerData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析超管移除管理员数据")
	user := new(ReceiveRemoveManager)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("超管移除管理员数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("解析超管移除管理员数据结束")

	config.GetLogger().Info("开始判断是否为超管")
	temp := 0
	err = db.Table("user_info").Where("id = ?", user.SuperID).Select("type").Row().Scan(&temp)
	if err != nil {
		data.IsRemove = false
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if temp != 2 {
		data.IsRemove = false
		config.GetLogger().Warnw("不是超管",
			"err", errors.New("不是超管"),
		)
		return errors.New("不是超管")
	}
	config.GetLogger().Info("判断是否为超管结束")

	config.GetLogger().Info("开始判断被移除者是否为管理员")
	temp = 0
	err = db.Table("user_info").Where("id = ?", user.ManagerID).Select("type").Row().Scan(&temp)
	if err != nil {
		data.IsRemove = false
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if temp != 1 {
		data.IsRemove = false
		config.GetLogger().Warnw("被移除者不是管理员",
			"err", errors.New("被移除者不是管理员"),
		)
		return errors.New("被移除者不是管理员")
	}
	config.GetLogger().Info("判断被移除者是否为管理员结束")

	config.GetLogger().Info("开始删除管理员与用户的关系")
	tx := db.Begin()
	remove := new(RemoveUserRelationship)
	err = tx.Table("relationship").Where("manager_id = ? ", user.ManagerID).Delete(&remove).Error
	if err != nil {
		data.IsRemove = false
		config.GetLogger().Warnw("删除管理员与用户的关系失败",
			"err", err,
		)
		tx.Rollback()
		return
	}
	config.GetLogger().Info("删除管理员与用户的关系结束")

	config.GetLogger().Info("开始移除管理员")
	err = tx.Table("user_info").Where("id = ? && type = 1", user.ManagerID).Update("type", 0).Error
	if err != nil {
		data.IsRemove = false
		config.GetLogger().Warnw("移除管理员失败",
			"err", err,
		)
		tx.Rollback()
		return
	}
	tx.Commit()
	config.GetLogger().Info("移除管理员结束")
	data.IsRemove = true
	return
}

/**
 * 超管添加管理员
 */
func (u *Admin) AddManager(cont string) (err error) {
	data := &u.AddManagerData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析超管添加管理员数据")
	user := new(ReceiveAddManager)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("超管添加管理员数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("解析超管添加管理员数据结束")

	config.GetLogger().Info("开始判断是否为超管")
	temp := 0
	err = db.Table("user_info").Where("id = ?", user.SuperID).Select("type").Row().Scan(&temp)
	if err != nil {
		data.IsAdd = false
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if temp != 2 {
		data.IsAdd = false
		config.GetLogger().Warnw("不是超管",
			"err", errors.New("不是超管"),
		)
		return errors.New("不是超管")
	}
	config.GetLogger().Info("判断是否为超管结束")

	config.GetLogger().Info("开始判断是否已为管理员")
	err = db.Table("user_info").Where("id = ?", user.UserID).Select("type").Row().Scan(&temp)
	if err != nil {
		data.IsAdd = false
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if temp != 0 {
		data.IsAdd = false
		config.GetLogger().Warnw("已为管理员",
			"err", errors.New("已为管理员"),
		)
		return errors.New("已为管理员")
	}
	config.GetLogger().Info("判断是否已为管理员结束")

	config.GetLogger().Info("开始判断是否已被管理员添加")
	count := 0
	err = db.Table("relationship").Where("normal_id = ?", user.UserID).Count(&count).Error
	if err != nil {
		data.IsAdd = false
		config.GetLogger().Warnw("判断是否已被管理员添加失败",
			"err", err,
		)
		return err
	}
	if count != 0 {
		data.IsAdd = false
		config.GetLogger().Warnw("已被管理员添加，无法申请管理员",
			"err", errors.New("已被管理员添加，无法申请管理员"),
		)
		return errors.New("已被管理员添加，无法申请管理员")
	}
	config.GetLogger().Info("判断是否已被管理员添加结束")

	config.GetLogger().Info("开始添加管理员")
	err = db.Table("user_info").Where("id = ?", user.UserID).Update("type", 1).Error
	if err != nil {
		data.IsAdd = false
		config.GetLogger().Warnw("添加管理员失败",
			"err", err,
		)
		return
	}
	err = db.Table("apply").Where("uid = ?", user.UserID).Update("status", 1).Error
	if err != nil {
		data.IsAdd = false
		config.GetLogger().Warnw("添加管理员失败",
			"err", err,
		)
		return
	}
	data.IsAdd = true
	config.GetLogger().Info("添加管理员结束")
	return
}

/**
 * 超管回复反馈
 */
func (u *Admin) ReplyFb(cont string) (err error) {
	data := &u.ReplyFbData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析超管回复反馈数据")
	user := new(ReceiveReplyFb)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("超管回复反馈数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("解析超管回复反馈数据结束")

	config.GetLogger().Info("开始回复")
	if user.Reply == "" {
		data.Success = false
		config.GetLogger().Warnw("反馈回复不能为空",
			"err", "反馈回复不能为空",
		)
		return errors.New("反馈回复不能为空")
	}

	tempStatus := 0
	row := db.Table("feedback").Where("id = ? ", user.FbID).Select("status").Row()
	err = row.Scan(&tempStatus)
	if err != nil {
		data.Success = false
		config.GetLogger().Warnw("获取回复状态失败",
			"err", err,
		)
		return
	}
	if tempStatus != 0 {
		data.Success = false
		config.GetLogger().Warnw("已回复",
			"err", errors.New("已回复"),
		)
		return errors.New("已回复")
	}
	err = db.Table("feedback").Where("id = ? ", user.FbID).Updates(map[string]interface{}{"answer": user.Reply, "status": 1}).Error
	if err != nil {
		data.Success = false
		config.GetLogger().Warnw("超管回复失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("回复结束")
	data.Success = true
	return
}

/**
 * 超管查看申请成为管理员列表
 */
func (u *Admin) CheckApplyList(cont string) (err error) {
	data := &u.CheckApplyListData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析数据")
	user := new(ReceiveCheckApplyList)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("数据解析结束")

	config.GetLogger().Info("开始判断是否为超管")
	tempType := 0
	err = db.Table("user_info").Where("id = ?", user.SuperID).Select("type").Row().Scan(&tempType)
	if err != nil {
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if tempType != 2 {
		config.GetLogger().Warnw("不是超管",
			"err", errors.New("不是超管"),
		)
		return errors.New("不是超管")
	}
	config.GetLogger().Info("判断是否为超管结束")

	config.GetLogger().Info("开始查询申请总数")
	err = db.Table("apply").Count(&data.Sum).Error
	if err != nil {
		config.GetLogger().Warnw("获取申请记录失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("查询申请总数结束")

	//用户申请列表
	config.GetLogger().Info("开始获取用户申请信息")
	rows, err := db.Table("apply").Order("status").Order("time desc").Joins("join user_info on user_info.id = apply.uid").
		Limit(user.PageSize).Offset((user.PageNum - 1) * user.PageSize).Select("uid, user, time, status").Rows()

	if err != nil {
		config.GetLogger().Warnw("获取用户申请信息失败",
			"err", err,
		)
		return
	}

	for rows.Next() {
		temp := new(CheckApplyData)
		temp.UserID = ""
		temp.UserName = ""
		temp.Status = 0
		tempTime := time.Now()

		err = rows.Scan(&temp.UserID, &temp.UserName, &tempTime, &temp.Status)
		if err != nil {
			config.GetLogger().Warnw("数据获取错误",
				"err:", err,
			)
			return err
		}
		temp.Time = tempTime.Format("2006-01-02 15:04:05")

		data.List = append(data.List, *temp)
	}

	config.GetLogger().Info("获取用户申请信息结束")

	return
}

/**
 * 超管查看管理员列表
 */
func (u *Admin) CheckManagerList(cont string) (err error) {
	data := &u.CheckManagerListData

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析数据")
	user := new(ReceiveCheckManagerList)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("数据解析结束")

	config.GetLogger().Info("开始判断是否为超管")
	tempType := 0
	err = db.Table("user_info").Where("id = ?", user.SuperID).Select("type").Row().Scan(&tempType)
	if err != nil {
		config.GetLogger().Warnw("获取用户类型失败",
			"err", err,
		)
		return
	}
	if tempType != 2 {
		config.GetLogger().Warnw("不是超管",
			"err", errors.New("不是超管"),
		)
		return errors.New("不是超管")
	}
	config.GetLogger().Info("判断是否为超管结束")

	config.GetLogger().Info("开始查询管理员总数")
	err = db.Table("user_info").Where("type = 1").Count(&data.Sum).Error
	if err != nil {
		config.GetLogger().Warnw("获取管理员总数失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("查询管理员总数结束")

	//管理员列表
	config.GetLogger().Info("开始获取管理员列表信息")
	rows, err := db.Table("user_info").Where("type = 1").Limit(user.PageSize).
		Offset((user.PageNum - 1) * user.PageSize).Select("id, user").Rows()

	if err != nil {
		config.GetLogger().Warnw("获取管理员列表信息失败",
			"err", err,
		)
		return
	}

	for rows.Next() {
		temp := new(CheckManagerData)
		temp.ManagerID = ""
		temp.ManagerName = ""

		err = rows.Scan(&temp.ManagerID, &temp.ManagerName)
		if err != nil {
			config.GetLogger().Warnw("数据获取错误",
				"err:", err,
			)
			return err
		}

		data.List = append(data.List, *temp)
	}

	config.GetLogger().Info("获取用户申请信息结束")

	return
}

/**
 * 超管查看所有用户
 */
func (u *Admin) CheckAll(cont string) (err error) {
	data := &u.CheckAllUser

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析数据")
	user := new(ReceiveCheckManagerList)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("数据解析结束")

	//所有人员列表
	config.GetLogger().Info("开始获取用户列表信息")
	err = db.Table("user_info").Where("type <= 1").Count(&data.Sum).Error
	if err != nil {
		config.GetLogger().Warnw("获取所有人员列表信息失败",
			"err", err,
		)
		return
	}

	rows, err := db.Table("user_info").Where("type <= 1").Limit(user.PageSize).
		Offset((user.PageNum - 1) * user.PageSize).Select("id, user, type").Rows()

	if err != nil {
		config.GetLogger().Warnw("获取所有人员列表信息失败",
			"err", err,
		)
		return
	}

	for rows.Next() {
		temp := new(CheckAllUserData)
		temp.UserID = ""
		temp.UserName = ""
		temp.UserType = ""

		err = rows.Scan(&temp.UserID, &temp.UserName, &temp.UserType)
		if err != nil {
			config.GetLogger().Warnw("数据获取错误",
				"err:", err,
			)
			return err
		}

		data.List = append(data.List, *temp)
	}

	config.GetLogger().Info("获取用户列表信息结束")

	return
}

/**
 * 超管查看登录日志
 */
func (u *Admin) CheckLoginLogger(cont string) (err error) {
	data := &u.LoginLogList

	//接收前端所传数据并解析
	config.GetLogger().Info("开始解析数据")
	user := new(ReceiveCheckManagerList)
	err = json.Unmarshal([]byte(cont), &user)
	if err != nil {
		config.GetLogger().Warnw("数据解析失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("数据解析结束")

	config.GetLogger().Info("开始登录记录总数")
	err = db.Table("login").Count(&data.Sum).Error
	if err != nil {
		config.GetLogger().Warnw("获取登录记录总数失败",
			"err", err,
		)
		return
	}
	config.GetLogger().Info("查询登录记录总数结束")

	//所有人员列表
	config.GetLogger().Info("开始获取用户登录日志信息")
	rows, err := db.Table("login").Order("time desc").Limit(user.PageSize).
		Offset((user.PageNum - 1) * user.PageSize).Select("id, username, time").Rows()

	if err != nil {
		config.GetLogger().Warnw("获取用户登录日志信息失败",
			"err", err,
		)
		return
	}

	for rows.Next() {
		temp := new(LoginLog)
		temp.UserID = ""
		temp.UserName = ""
		tempTime := time.Now()

		err = rows.Scan(&temp.UserID, &temp.UserName, &tempTime)
		if err != nil {
			config.GetLogger().Warnw("数据获取错误",
				"err:", err,
			)
			return err
		}
		temp.Time = tempTime.Format("2006-01-02 15:04:05")

		data.List = append(data.List, *temp)
	}

	config.GetLogger().Info("获取用户登录日志信息结束")

	return
}

//--------------------------------------------------------------------------

func (u *Admin) GetAddUserData(cont string) (err error, data AdduserData) {
	config.GetLogger().Info("开始上传用户关系")

	err = u.addUser(cont)

	data = u.AdduserData

	config.GetLogger().Info("上传用户关系结束")

	return
}

func (u *Admin) GetRemoveUserData(cont string) (err error, data RemoveUserData) {
	config.GetLogger().Info("开始删除用户关系")

	err = u.removeUser(cont)

	data = u.RemoveUserData

	config.GetLogger().Info("删除用户关系结束")

	return
}

func (u *Admin) GetDeleteUserData(cont string) (err error, data RemoveUserData) {
	config.GetLogger().Info("开始删除用户")

	err = u.delUser(cont)

	data = u.RemoveUserData

	config.GetLogger().Info("删除用户结束")
	return
}

func (u *Admin) GetCheckFeedbackData(cont string) (err error, data CheckFeedbackData) {
	config.GetLogger().Info("开始查询用户反馈信息")

	err = u.CheckFeedback(cont)

	data = u.CheckFeedbackData

	config.GetLogger().Info("查询用户反馈信息结束")

	return
}

func (u *Admin) GetCheckUserListData(cont string) (err error, data CheckUserListData) {
	config.GetLogger().Info("开始查询用户反馈信息")

	err = u.CheckUserList(cont)

	data = u.CheckUserListData

	config.GetLogger().Info("查询用户反馈信息结束")
	return
}

func (u *Admin) GetRemoveManagerData(cont string) (err error, data RemoveManagerData) {
	config.GetLogger().Info("开始获取移除管理员信息")

	err = u.RemoveManager(cont)

	data = u.RemoveManagerData

	config.GetLogger().Info("获取移除管理员信息结束")
	return
}

func (u *Admin) GetAddManagerData(cont string) (err error, data AddManagerData) {
	config.GetLogger().Info("开始获取添加管理员信息")

	err = u.AddManager(cont)

	data = u.AddManagerData

	config.GetLogger().Info("获取添加管理员信息结束")
	return
}

func (u *Admin) GetReplyFbData(cont string) (err error, data ReplyFbData) {
	config.GetLogger().Info("开始获取回复反馈信息")

	err = u.ReplyFb(cont)

	data = u.ReplyFbData

	config.GetLogger().Info("获取回复反馈信息结束")

	return
}

func (u *Admin) GetCheckApplyListData(cont string) (err error, data CheckApplyListData) {
	config.GetLogger().Info("开始获取申请信息")

	err = u.CheckApplyList(cont)

	data = u.CheckApplyListData

	config.GetLogger().Info("获取申请信息结束")

	return
}

func (u *Admin) GetCheckManagerListData(cont string) (err error, data CheckManagerListData) {
	config.GetLogger().Info("开始获取申请信息")

	err = u.CheckManagerList(cont)

	data = u.CheckManagerListData

	config.GetLogger().Info("获取申请信息结束")

	return
}

func (u *Admin) GetCheckAllUserListData(cont string) (err error, data CheckAllUserListData) {
	config.GetLogger().Info("开始获取所有人员信息")

	err = u.CheckAll(cont)

	data = u.CheckAllUser

	config.GetLogger().Info("获取所有人员信息结束")

	return
}

func (u *Admin) GetCheckLoginLoggerListData(cont string) (err error, data LoginLogList) {
	config.GetLogger().Info("开始获取登录信息")

	err = u.CheckLoginLogger(cont)

	data = u.LoginLogList

	config.GetLogger().Info("获取登录信息结束")

	return
}
